home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / c / chunky.lha / lib_chunky / tst-src / test2.c < prev    next >
C/C++ Source or Header  |  1998-02-26  |  4KB  |  191 lines
  1. /*
  2. ** test2.c
  3. **
  4. ** Tests the various insert functions and prints the execution time
  5. **
  6. ** compile me with
  7. ** gcc -noixemul -s -m68020 -O2 -o test2 test2.c -lchunky -lm
  8. */
  9. #define __CONSTLIBBASEDECL__  const
  10. #include  <exec/execbase.h>
  11. #include  <intuition/screens.h>
  12. #include  <graphics/gfx.h>
  13. #include  <hardware/custom.h>
  14. #include  <hardware/cia.h>
  15. #include  <hardware/dmabits.h>
  16.  
  17. #include  <proto/exec.h>
  18. #include  <proto/intuition.h>
  19. #include  <proto/graphics.h>
  20.  
  21. #include  <stdlib.h>
  22. #include  <time.h>
  23.  
  24. #include  "../lib-src/chunky.h"
  25.  
  26. #ifndef __GNUC__
  27. extern  __far struct CIA    ciaa;
  28. extern  __far struct CIA    ciab;
  29. extern  __far struct Custom custom;
  30. #else
  31. extern struct CIA     ciaa;
  32. extern struct CIA     ciab;
  33. extern struct Custom  custom;
  34. #endif
  35.  
  36. #define SX  640
  37. #define SY  480
  38. #define CX  320
  39. #define CY  240
  40.  
  41. struct  Screen      *scr;
  42. struct  RastPort    *rp;
  43. struct  ChunkyPort  *cp;
  44.  
  45. /*///"Time functions"*/
  46. void PTimeStart( BOOL dmaoff )
  47. {
  48.     WaitTOF();
  49.     Forbid();
  50.     Disable();
  51.  
  52.     if( dmaoff )  custom.dmacon = DMAF_MASTER;
  53.  
  54.     ciab.ciacra = 0;      /* Timer a und b stoppen */
  55.     ciab.ciacrb = 0;
  56.  
  57.     ciab.ciatalo= 0xff;    /* TimerA = $ffff */
  58.     ciab.ciatahi= 0xff;
  59.  
  60.     ciab.ciatblo= 0xff;    /* TimerB = $ffff */
  61.     ciab.ciatbhi= 0xff;
  62.  
  63.     /* TimerB start mit INMODE1 set, da 32bit-Zähler */
  64.     ciab.ciacrb = CIACRBF_START|CIACRBF_INMODE1;
  65.  
  66.     /* TimerA start normal */
  67.     ciab.ciacra = CIACRAF_START;
  68.  
  69. }
  70.  
  71. ULONG PTimeStop( void )
  72. {
  73.     ULONG cycles;
  74.  
  75.     ciab.ciacra = 0;  /* Timer a und b stoppen */
  76.     ciab.ciacrb = 0;
  77.  
  78.     cycles =  0xffffffff -
  79.                         ( ( ciab.ciatalo ) + ( ciab.ciatahi * 0x100 ) +
  80.                             ( ciab.ciatblo * 0x10000 ) + ( ciab.ciatbhi * 0x1000000 ) );
  81.  
  82.     custom.dmacon = DMAF_SETCLR | DMAF_MASTER;
  83.  
  84.     Enable();
  85.     Permit();
  86.     return( cycles );
  87. }
  88.  
  89. void PPrintTime( char *head, ULONG val )
  90. {
  91.     struct ExecBase *sb = SysBase;
  92.     ULONG correct;
  93.     ULONG realtime;
  94.     ULONG etime = sb->ex_EClockFrequency;
  95.  
  96.     /* Calculate real time needed */
  97.     PTimeStart( 0 );
  98.     correct = PTimeStop();
  99.  
  100.     realtime = val - correct;
  101.  
  102.     printf( "Elapsed time for function %s: %f sec. \n", (LONG )head,
  103.     (float )((float )realtime/(float )etime ) );
  104. }
  105. /*///*/
  106. ///"Test functions "
  107. void chk_draw( struct ChunkyPort *cp )
  108. {
  109.     // Draw some outline boxes into the cp
  110.     int i;
  111.     int sx = 16;
  112.     int sy = 16;
  113.     int x, y;
  114.  
  115.     srand( (unsigned )time(NULL));
  116.  
  117.     for( i= 0; i<255; i++ ){
  118.         SetAPenChk( cp, i%255);
  119.         sx = rand() % CX;
  120.         sy = rand() % CY;
  121.         x = rand() % (CX-sx);
  122.         y = rand() % (CY-sy);
  123.         RectChk( cp, x, y, x+sx, y+sy );
  124.     }
  125. }
  126.  
  127. void rpt_draw( void )
  128. {
  129.     SetRast( rp, 1 );
  130.     WaitBlit();
  131. }
  132.  
  133. void chk_test( void )
  134. {
  135.     // This routine uses the InsertChunkyPort() function to
  136.     // plot the ChunkyPort into the RastPort
  137.     chk_draw( cp );
  138.     rpt_draw();
  139.     PTimeStart(0);
  140.     InsertChunkyPort( cp, rp, (SX-CX)/2, (SY-CY)/2 );
  141.     PPrintTime( "InsertChunkyPort()", PTimeStop());
  142. }
  143.  
  144. void chk_test2( void )
  145. {
  146.     // This routine uses the CreateChunkyFromRastPort() function to
  147.     // get a 'squizzy paper' as background for our rendering functions
  148.     // This might be usefull if you want to chunky-draw into a picture
  149.  
  150.     struct ChunkyPort *c2;
  151.     int    x = (SX-CX)/2, y = (SY-CY)/2;
  152.  
  153.     if( c2 = CreateChunkyFromRastPort( rp, x, y, CX-1, CY-1 ) ){
  154.         rpt_draw();
  155.         chk_draw(c2);
  156.  
  157.         PTimeStart(0);
  158.         DrawChunkyPort( c2, rp, (SX-CX)/2, (SY-CY)/2 );
  159.         PPrintTime( "CreateChunkyFromRastPort()", PTimeStop());
  160.  
  161.         FreeChunkyPort( c2 );
  162.     }
  163. }
  164.  
  165. ///
  166. ///"main function"
  167. int main( void )
  168. {
  169.     if( scr = OpenScreenTags( NULL, SA_DisplayID, 0x39024,    // VGA: Productivity
  170.                                                                     SA_Width,     SX,
  171.                                                                     SA_Height,    SY,
  172.                                                                     SA_Depth,     8,
  173.                                                                     SA_Interleaved, TRUE,
  174.                                                                     TAG_DONE ) )
  175.     {
  176.         rp = &scr->RastPort;
  177.  
  178.         if( cp = InitChunkyPort( CX, CY ) )
  179.         {
  180.             /* Draw something */
  181.             chk_test();
  182.             chk_test2();
  183.             FreeChunkyPort( cp );
  184.         }
  185.         Delay( 250 );
  186.         CloseScreen( scr );
  187.     }
  188. }
  189. ///
  190.  
  191.